package com.ruoyi.common.utils;


import org.apache.commons.io.FilenameUtils;

import java.io.*;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Properties;
import java.util.Random;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;

/**
 * 文件工具
 * 
 * @author zhanghaitao
 *
 */
@SuppressWarnings("deprecation")
public class FileUtil {
//	private static Logger logger = Logger.getLogger(FileUtil.class);

	/**
	 * 获得文件的CRC32校验和
	 *
	 * @param file
	 * @return
	 * @throws Exception
	 */
	public static String getFileCRCCode(File file) throws Exception {
		FileInputStream is = new FileInputStream(file);
		CRC32 crc32 = new CRC32();
		CheckedInputStream cis = new CheckedInputStream(is, crc32);
		byte[] buffer = null;
		buffer = new byte[1024];
		while (cis.read(buffer) != -1) {
		}
		is.close();
		buffer = null;
		return Long.toHexString(crc32.getValue());
	}

	/**
	 * 获得字串的CRC32校验和
	 *
	 * @param string
	 * @return
	 * @throws Exception
	 */
	public static String getStringCRCCode(String string) throws Exception {
		StringBufferInputStream inputStream = new StringBufferInputStream(
				string);

		CRC32 crc32 = new CRC32();
		CheckedInputStream checkedinputstream = new CheckedInputStream(
				inputStream, crc32);
		byte[] buffer = null;
		buffer = new byte[1024];
		while (checkedinputstream.read(buffer) != -1) {
		}
		inputStream.close();
		buffer = null;
		return Long.toHexString(crc32.getValue());
	}

	/**
	 * 连接路径和文件名称，组成最后的包含路径的文件名
	 *
	 * @param basePath
	 *            文件路径
	 * @param fullFilenameToAdd
	 *            文件名称
	 * @return
	 */
	public static String concat(String basePath, String fullFilenameToAdd) {
		return FilenameUtils.concat(basePath, fullFilenameToAdd);
	}

	/**
	 * 获得不带文件扩展名的文件名称
	 *
	 * @param filename
	 *            文件完整路径
	 * @return 不带扩展名的文件名称
	 */
	public static String getBaseName(String filename) {
		return FilenameUtils.getBaseName(filename);
	}

	/**
	 * 获得带扩展名的文件名称
	 *
	 * @param filename
	 *            文件完整路径
	 * @return 文件名称
	 */
	public static String getFileName(String filename) {
		return FilenameUtils.getName(filename);
	}

	/**
	 * 获得文件的完整路径，包含最后的路径分隔条
	 *
	 * @param filename
	 *            文件完整路径
	 * @return 目录结构
	 */
	public static String getFullPath(String filename) {
		return FilenameUtils.getFullPath(filename);
	}

	/**
	 * 获得文件的完整路径，不包含最后的路径分隔条
	 *
	 * @param filename
	 * @return
	 */
	public static String getFullPathNoEndSeparator(String filename) {
		return FilenameUtils.getFullPathNoEndSeparator(filename);
	}

	/**
	 * 判断文件是否有某扩展名
	 *
	 * @param filename
	 *            文件完整路径
	 * @param extension
	 *            扩展名名称
	 * @return 若是，返回true，否则返回false
	 */
	public static boolean isExtension(String filename, String extension) {
		return FilenameUtils.isExtension(filename, extension);
	}

	/**
	 * 判断文件的扩展名是否是扩展名数组中的一个
	 *
	 * @param filename
	 *            文件完整路径
	 * @param extensions
	 *            扩展名名称
	 * @return 若是，返回true，否则返回false
	 */
	public static boolean isExtension(String filename, String[] extensions) {
		return FilenameUtils.isExtension(filename, extensions);
	}

	/**
	 * 规范化路径，合并其中的多个分隔符为一个,并转化为本地系统路径格式
	 *
	 * @param filename
	 * @return
	 */
	public static String normalize(String filename) {
		return FilenameUtils.normalize(filename);
	}

	/**
	 * 规范化路径，合并其中的多个分隔符为一个,并转化为本地系统路径格式,若是路径，则不带最后的路径分隔符
	 *
	 * @param filename
	 * @return
	 */
	public static String normalizeNoEndSeparator(String filename) {
		return FilenameUtils.normalizeNoEndSeparator(filename);
	}

	/**
	 * 把文件路径中的分隔符转换为unix的格式，也就是"/"
	 *
	 * @param path
	 *            文件完整路径
	 * @return 转换后的路径
	 */
	public static String separatorsToUnix(String path) {
		return FilenameUtils.separatorsToUnix(path);
	}

	/**
	 * 把文件路径中的分隔符转换为window的格式，也就是"\"
	 *
	 * @param path
	 *            文件完整路径
	 * @return 转换后的路径
	 */
	public static String separatorsToWindows(String path) {
		return FilenameUtils.separatorsToWindows(path);
	}

	/**
	 * 把文件路径中的分隔符转换当前系统的分隔符
	 *
	 * @param path
	 *            文件完整路径
	 * @return 转换后的路径
	 */
	public static String separatorsToSystem(String path) {
		return FilenameUtils.separatorsToSystem(path);
	}

	/**
	 * 提取文件的扩展名
	 *
	 * @param filename
	 *            文件名称
	 * @return 文件扩展名，若没有扩展名，则返回空字符串
	 */
	public static String getExtension(String filename) {
		return FilenameUtils.getExtension(filename);
	}

	/**
	 * 移出文件的扩展名
	 *
	 * @param filename
	 *            文件名称
	 * @return 若文件存在扩展名，则移出扩展名，然后返回移出后的值
	 */
	public static String removeExtension(String filename) {
		return FilenameUtils.removeExtension(filename);
	}

	/**
	 * 清除一个目录的内容，但不删除此目录
	 *
	 * @param directory
	 *            需要清除的目录
	 * @return true:清除成功 false:清除失败
	 */
	public static boolean cleanDirectory(File directory) {
		try {
			org.apache.commons.io.FileUtils.cleanDirectory(directory);
			return true;
		} catch (IOException ex) {
//		    LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 拷贝一个目录的内容到另外一个目录中
	 *
	 * @param srcDir
	 *            源目录
	 * @param destDir
	 *            目的目录
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyDirectory(File srcDir, File destDir) {
		return copyDirectory(srcDir, destDir, true);
	}

	/**
	 * 拷贝一个目录的内容到另外一个目录中
	 *
	 * @param srcDir
	 *            源目录
	 * @param destDir
	 *            目的目录
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyDirectory(String srcDir, String destDir) {
		return copyDirectory(new File(srcDir), new File(destDir));
	}

	/**
	 * 拷贝一个目录的内容到另外一个目录中
	 *
	 * @param srcDir
	 *            源目录
	 * @param destDir
	 *            目的目录
	 * @param preserveFileDate
	 *            是否保持文件日期
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyDirectory(File srcDir, File destDir,
			boolean preserveFileDate) {
		try {
			org.apache.commons.io.FileUtils.copyDirectory(srcDir, destDir,
					preserveFileDate);
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 拷贝源目录的内容到目的目录中(注：是拷贝到目的目录的里面)
	 *
	 * @param srcDir
	 *            源目录
	 * @param destDir
	 *            目的目录
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyDirectoryToDirectory(File srcDir, File destDir) {
		try {
			org.apache.commons.io.FileUtils.copyDirectoryToDirectory(srcDir,
					destDir);
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 拷贝源目录的内容到目的目录中(注：是拷贝到目的目录的里面)
	 *
	 * @param srcDir
	 *            源目录
	 * @param destDir
	 *            目的目录
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyDirectoryToDirectory(String srcDir, String destDir) {
		return copyDirectoryToDirectory(new File(srcDir), new File(destDir));
	}

	/**
	 * 拷贝文件
	 *
	 * @param srcFile
	 *            源文件
	 * @param destFile
	 *            目的文件
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyFile(File srcFile, File destFile) {
		return copyFile(srcFile, destFile, true);
	}

	/**
	 * 拷贝文件
	 *
	 * @param srcFile
	 *            源文件路径
	 * @param destFile
	 *            目的文件路径
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyFile(String srcFile, String destFile) {
		return copyFile(new File(srcFile), new File(destFile));
	}

	/**
	 * 拷贝文件
	 *
	 * @param srcFile
	 *            源文件
	 * @param destFile
	 *            目的文件
	 * @param preserveFileDate
	 *            是否保留文件日期
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyFile(File srcFile, File destFile,
			boolean preserveFileDate) {
		try {
			org.apache.commons.io.FileUtils.copyFile(srcFile, destFile,
					preserveFileDate);
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 拷贝文件到某目录中
	 *
	 * @param srcFile
	 *            源文件
	 * @param destDir
	 *            目的目录
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyFileToDirectory(File srcFile, File destDir) {
		try {
			org.apache.commons.io.FileUtils.copyFileToDirectory(srcFile,
					destDir);
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 拷贝文件到某目录中
	 *
	 * @param srcFile
	 *            源文件
	 * @param destDir
	 *            目的目录
	 * @return true:拷贝成功 false:拷贝失败
	 */
	public static boolean copyFileToDirectory(String srcFile, String destDir) {
		return copyFileToDirectory(new File(srcFile), new File(destDir));
	}

	/**
	 * 删除一个目录和该目录下的所有内容
	 *
	 * @param directory
	 *            需要删除的目录
	 * @return true:删除成功 false:删除失败
	 */
	public static boolean deleteDirectory(String directory) {
		try {
			org.apache.commons.io.FileUtils
					.deleteDirectory(new File(directory));
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 删除文件
	 *
	 * @param file
	 *            需要删除的文件路径
	 * @return true:删除成功 false:删除失败
	 */
	public static boolean deleteFile(String file) {
		try {
			org.apache.commons.io.FileUtils.forceDelete(new File(file));
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 递归创建目录
	 *
	 * @param directory
	 * @return
	 */
	public static boolean createDirectory(String directory) {
		try {
			org.apache.commons.io.FileUtils.forceMkdir(new File(directory));
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 读入文件到字节数组中
	 *
	 * @param file
	 *            需要读取的文件路径
	 * @return 读取的字节数组，若读入失败，则返回null
	 */
	public static byte[] readFileToByteArray(String file) {
		try {
			byte[] bytes = org.apache.commons.io.FileUtils
					.readFileToByteArray(new File(file));
			return bytes;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return null;
	}

	/**
	 * 读入文件到字串中
	 *
	 * @param file
	 *            需要读取的文件路径
	 * @return 读取的文件内容，若读入失败，则返回空字串
	 */
	public static String readFileToString(String file, String encoding) {
		try {
			String content = org.apache.commons.io.FileUtils.readFileToString(
					new File(file), encoding);
			return content;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return "";
	}

	/**
	 * 读入文本文件到一个按行分开的List中
	 *
	 * @param file
	 *            需要读取的文件路径
	 * @return 按行内容分开的List
	 */
	@SuppressWarnings("rawtypes")
	public static List readLines(String file) {
		try {
			List lineList = org.apache.commons.io.FileUtils.readLines(new File(
					file), "GBK");
			return lineList;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return null;
	}

	/**
	 * 递归求一个目录的容量大小
	 *
	 * @param directory
	 *            需要计算容量的目录路径
	 * @return 容量的大小(字节数)
	 */
	public static long sizeOfDirectory(String directory) {
		return org.apache.commons.io.FileUtils.sizeOfDirectory(new File(
				directory));
	}

	/**
	 * 写字节数组到文件中，若文件不存在，则建立新文件
	 *
	 * @param file
	 *            需要写的文件的路径
	 * @param data
	 *            需要写入的字节数据
	 * @return true:写入成功 false:写入失败
	 */
	public static boolean writeToFile(String file, byte[] data) {
		try {
			org.apache.commons.io.FileUtils.writeByteArrayToFile(
					new File(file), data);
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 写字串到文件中，若文件不存在，则建立新文件
	 *
	 * @param file
	 *            需要写的文件的路径
	 * @param data
	 *            需要写入的字串
	 * @return true:写入成功 false:写入失败
	 */
	public static boolean writeToFile(String file, String data) {
		try {
			org.apache.commons.io.FileUtils.writeStringToFile(new File(file),
					data, "GBK");
			return true;
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
		}
		return false;
	}

	/**
	 * 建立由filePathName指定的文件，若文件路径中的目录不存在，则先建立目录
	 *
	 * @param filePathName
	 *            文件路径全名
	 * @return
	 */
	public static boolean createNewFile(String filePathName) {
		String filePath = FileUtil.getFullPath(filePathName);
		// 若目录不存在，则建立目录
		if (!FileUtil.exists(filePath)) {
			if (!createDirectory(filePath))
				return false;
		}

		try {
			File file = new File(filePathName);
			return file.createNewFile();
		} catch (IOException ex) {
//			LoggerUtil.error(logger, ex, "FileUtil异常");
			return false;
		}
	}

	/**
	 * 判断文件和目录是否已存在
	 *
	 * @param filePath
	 *            文件和目录完整路径
	 * @return tru:存在 false：不存在
	 */
	public static boolean exists(String filePath) {
		File file = new File(filePath);
		return file.exists();
	}

	/**
	 * 判断特定的路径是否为文件
	 *
	 * @param filePath
	 *            文件完整的路径
	 * @return 若是文件，则返回true，否则返回false
	 */
	public static boolean isFile(String filePath) {
		File file = new File(filePath);
		return file.isFile();
	}

	/**
	 * 判断特定的路径是否为目录
	 *
	 * @param filePath
	 *            文件完整的路径
	 * @return 若是目录，则返回true，否则返回false
	 */
	public static boolean isDirectory(String filePath) {
		File file = new File(filePath);
		return file.isDirectory();
	}

	/**
	 * 更改文件的名称，若不在同一个目录下,则系统会移动文件
	 *
	 * @param srcFile
	 *            源文件路径名称
	 * @param destFile
	 *            目的文件路径名称
	 * @return
	 */
	public static boolean renameTo(String srcFile, String destFile) {
		File file = new File(srcFile);
		return file.renameTo(new File(destFile));
	}

	/**
	 * 复制文件并改名
	 * 
	 * @param srcFile
	 *            源文件路径
	 * @param destFile
	 *            目标文件路径
	 * @param oldName
	 *            原文件名
	 * @param rename
	 *            修改的名字
	 * @return
	 */
	public static boolean copyAndRename(String srcFile, String destFile,
			String oldName, String rename) {
		copyFileToDirectory(srcFile, destFile);
		return renameTo(destFile + oldName, destFile + rename);
	}

	/**
	 * 得到文件Hash值(MD5加密)
	 * 
	 * @param filename
	 *            文件路径
	 * @return 文件Hash值(MD5加密)
	 */
	public static String getMD5Checksum(String filename) {
		// 得到文件Hash值字节集合
		byte[] b = createChecksum(filename);

		String result = "";

		for (int i = 0; i < b.length; i++) {
			result += Integer.toString((b[i] & 0xff) + 0x100, 16).substring(1);
		}

		return result;
	}

	/**
	 * 得到文件Hash值字节集合
	 * 
	 * @param filename
	 *            文件路径
	 * @return 文件Hash值
	 */
	private static byte[] createChecksum(String filename) {
		// 文件输入流
		InputStream fis = null;
		// 使用MD5对Hash值进行加密
		MessageDigest complete = null;

		byte[] buffer = new byte[1024];

		byte[] hashBuffer = new byte[0];

		try {
			fis = new FileInputStream(filename);
			complete = MessageDigest.getInstance("MD5");

			int numRead;
			do {
				numRead = fis.read(buffer);
				if (numRead > 0) {
					complete.update(buffer, 0, numRead);
				}
			} while (numRead != -1);

			hashBuffer = complete.digest();

		} catch (FileNotFoundException e) {
//			LoggerUtil.error(logger, e, "FileUtil异常");
		} catch (IOException e) {
//			LoggerUtil.error(logger, e, "FileUtil异常");
		} catch (Exception e) {
//			LoggerUtil.error(logger, e, "FileUtil异常");
		} finally {
			if (null != fis) {
				try {
					fis.close();
				} catch (IOException e) {
//					LoggerUtil.error(logger, e, "FileUtil异常");
				}
			}
		}

		return hashBuffer;
	}

	/**
	 * （前缀+系统的当前时间+后缀)创建一个唯一的文件名
	 * 
	 * @param prefix
	 *            文件前缀
	 * @param suffix
	 *            文件后缀
	 * @return String 创建一个唯一的文件名
	 * @see [类、类#方法、类#成员]
	 */
	public static String generateFileName(String prefix, String suffix) {
		if (null == prefix) {
			prefix = "";
		}

		if (null == suffix) {
			suffix = "";
		}

		return (prefix + Long.toString(System.currentTimeMillis()) + suffix);
	}

	/**
	 * 替换文件前缀(file://替换为file:/,主要解决linux环境下出现file://导致签章图片显示不出来问题)
	 * 
	 * @param filePath
	 *            文件路径
	 * @return String 替换后的文件路径
	 * @exception throws [违例类型] [违例说明]
	 * @see [类、类#方法、类#成员]
	 */
	public static String replaceFilePathPrefix(String filePath) {
		if (StringUtils.isEmpty(filePath)) {
			return filePath;
		}

		return filePath.replaceAll("file://", "file:/");
	}
	
	 /**
     * 得到基本路径
     * @return
     */
    public static String getBasePath(){
   	 Properties prop = System.getProperties();
		 String os = prop.getProperty("os.name");
		if(os.startsWith("win") || os.startsWith("Win")){
			String path="D:/code/image/supplier";
			return new File(path).getPath();
		}else{
			return "/code/image/supplier";
		}
		 
    }
	 /**
     * 得到图片
     * @return
     */
    public static String getImagePath(){
   	 Properties prop = System.getProperties();
		 String os = prop.getProperty("os.name");
		 if(os.startsWith("win") || os.startsWith("Win")){
			String path="D:/code/image/supplier";
			return new File(path).getPath();
		}else{
			return "/data/profile/upload";
		}
		 
    }
	public static byte[] getBytesFromFile(File f){  
        if (f == null){  
            return null;  
        }  
        FileInputStream stream = null;
        ByteArrayOutputStream out = null;
        try{  
            stream = new FileInputStream(f);  
            out = new ByteArrayOutputStream(1000);  
            byte[] b = new byte[1000];  
            int n;  
            while ((n = stream.read(b)) != -1)  
                out.write(b, 0, n);  
            return out.toByteArray();  
        } catch (IOException e){  
         //   LoggerUtil.error(logger, e, "获取文件bytes数组异常");
        }  finally {
            if (stream != null) try {
                stream.close();
            } catch (IOException e) {
//                LoggerUtil.error(logger, e, "关闭io异常");
            }
            if (out != null) try {
                out.close();
            } catch (IOException e) {
         //       LoggerUtil.error(logger, e, "关闭io异常");
            }
        }
        return null;  
    }  
	/**
	 * 项目启动路径 例如截取“www.qhfax.com”
	 * @return
	 * @author chenyanling
	 */
	 public static String getServerPath(){
		  String basePath= FileUtil.getBasePath().substring(0, FileUtil.getBasePath().lastIndexOf("/")+1);//Constants.PROJECT_PATH  "http://192.168.1.51:8080/path"
	      return basePath;
	  }
	 
    /**
     * 重新生成文件名字
     * 
     * @param save_path
     * @return
     */
    public static String getNewFileName(String save_path, int i) {
        StringBuffer filename = new StringBuffer("");
        String extName = ""; // 保存文件拓展名
        String newFileName = ""; // 保存新的文件名
        String nowTimeStr = ""; // 保存当前时间
        // 生成随机文件名：当前年月日时分秒+五位随机数（为了在实际项目中防止文件同名而进行的处理
        // int rannum = (int) (r.nextDouble() * (99999 - 10000 + 1)) + 10000; //
        // 获取随机数
        SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyyMMddHHmmss"); // 时间格式化的格式
        Date date = DateUtils.addMinute(new Date(), i);
        nowTimeStr = sDateFormat.format(date); // 当前时间
        // 获取拓展名
        if (save_path.lastIndexOf(".") >= 0) {
        extName = save_path.substring(save_path.lastIndexOf("."));
        }
        newFileName = nowTimeStr + extName; // 文件重命名后的名称
        filename.append(newFileName);
        return filename.toString();
    }
	/**
	 * 重新生成文件名字
	 * 
	 * @param save_path
	 * @return
	 */
	public static String getNewFileName(String save_path) {
		StringBuffer filename = new StringBuffer("");
		Random r = new Random();
		String extName = ""; // 保存文件拓展名
		String newFileName = ""; // 保存新的文件名
		String nowTimeStr = ""; // 保存当前时间
		// 生成随机文件名：当前年月日时分秒+五位随机数（为了在实际项目中防止文件同名而进行的处理＄1��7
		int rannum = (int) (r.nextDouble() * (99999 - 10000 + 1)) + 10000; // 获取随机敄1��7
		SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyyMMddHHmmss"); // 时间格式化的格式
		nowTimeStr = sDateFormat.format(new Date()); // 当前时间
		// 获取拓展名
		if (save_path.lastIndexOf(".") >= 0) {
			extName = save_path.substring(save_path.lastIndexOf("."));
		}
		newFileName = nowTimeStr +rannum+ extName; // 文件重命名后的名称
		filename.append(newFileName);
		return filename.toString();
	}
    /**
     * 删除服务器上的图片
     * @param paths
     */
    public static void delFileByPath(String path){      
        if(StringUtils.isNotEmpty(path)){
            String absoluteFilePath = FileUtil.getBasePath()+"/"+path;
            FileUtil.deleteDirectory(absoluteFilePath);
        }
    }
    
    /**
     * 删除文件夹
     * @author zhanghaitao
     * @param filePath 文件路径
     */
    public static void delFolder(String filePath) {
        try {
            delAllFile(filePath); // 删除完里面所有内容
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            myFilePath.delete(); // 删除空文件夹
        } catch (Exception e) {
//            LoggerUtil.error(logger, e, "删除文件夹异常");
        }
    }
    
    /**
     * 删除指定文件夹下所有文件
     * @author zhanghaitao
     * @param path 文件夹完整绝对路径
     * @return
     */
    private static boolean delAllFile(String path) {
        boolean flag = false;
        File file = new File(path);
        if (!file.exists()) {
            return flag;
        }
        if (!file.isDirectory()) {
            return flag;
        }
        String[] tempList = file.list();
        File temp = null;
        for (int i = 0; i < tempList.length; i++) {
            if (path.endsWith(File.separator)) {
                temp = new File(path + tempList[i]);
            } else {
                temp = new File(path + File.separator + tempList[i]);
            }
            if (temp.isFile()) {
                temp.delete();
            }
            if (temp.isDirectory()) {
                delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
                delFolder(path + "/" + tempList[i]);// 再删除空文件夹
                flag = true;
            }
        }
        return flag;
    }
}
